<?xml version='1.0' encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html lang="en" xml:lang="en" xmlns="http://www.w3.org/1999/xhtml">
  <head>
    <link href="cpip.css" rel="stylesheet" type="text/css" />
    <title>File: /Users/paulross/dev/linux/linux-3.13/include/linux/llist.h</title>
  </head>
  <body>
    <h1>File: /Users/paulross/dev/linux/linux-3.13/include/linux/llist.h</h1>
    <p>Green shading in the line number column
means the source is part of the translation unit, red means it is conditionally excluded.
Highlighted line numbers link to the translation unit page. Highlighted macros link to
the macro page.</p>
    <pre><a name="1" /><span class="Maybe">       1:</span> <span class="f">#</span><span class="n">ifndef</span> <a href="cpu.c_macros_ref.html#_TExJU1RfSF8w"><span class="b">LLIST_H</span></a>
<a name="2" /><span class="Maybe">       2:</span> <span class="f">#</span><span class="n">define</span> <a href="cpu.c_macros_ref.html#_TExJU1RfSF8w"><span class="b">LLIST_H</span></a>
<a name="3" /><span class="Maybe">       3:</span> <span class="k">/*</span>
<a name="4" /><span class="Maybe">       4:</span> <span class="k"> * Lock-less NULL terminated single linked list</span>
<a name="5" /><span class="Maybe">       5:</span> <span class="k"> *</span>
<a name="6" /><span class="Maybe">       6:</span> <span class="k"> * If there are multiple producers and multiple consumers, llist_add</span>
<a name="7" /><span class="Maybe">       7:</span> <span class="k"> * can be used in producers and llist_del_all can be used in</span>
<a name="8" /><span class="Maybe">       8:</span> <span class="k"> * consumers.  They can work simultaneously without lock.  But</span>
<a name="9" /><span class="Maybe">       9:</span> <span class="k"> * llist_del_first can not be used here.  Because llist_del_first</span>
<a name="10" /><span class="Maybe">      10:</span> <span class="k"> * depends on list-&gt;first-&gt;next does not changed if list-&gt;first is not</span>
<a name="11" /><span class="Maybe">      11:</span> <span class="k"> * changed during its operation, but llist_del_first, llist_add,</span>
<a name="12" /><span class="Maybe">      12:</span> <span class="k"> * llist_add (or llist_del_all, llist_add, llist_add) sequence in</span>
<a name="13" /><span class="Maybe">      13:</span> <span class="k"> * another consumer may violate that.</span>
<a name="14" /><span class="Maybe">      14:</span> <span class="k"> *</span>
<a name="15" /><span class="Maybe">      15:</span> <span class="k"> * If there are multiple producers and one consumer, llist_add can be</span>
<a name="16" /><span class="Maybe">      16:</span> <span class="k"> * used in producers and llist_del_all or llist_del_first can be used</span>
<a name="17" /><span class="Maybe">      17:</span> <span class="k"> * in the consumer.</span>
<a name="18" /><span class="Maybe">      18:</span> <span class="k"> *</span>
<a name="19" /><span class="Maybe">      19:</span> <span class="k"> * This can be summarized as follow:</span>
<a name="20" /><span class="Maybe">      20:</span> <span class="k"> *</span>
<a name="21" /><span class="Maybe">      21:</span> <span class="k"> *           |   add    | del_first |  del_all</span>
<a name="22" /><span class="Maybe">      22:</span> <span class="k"> * add       |    -     |     -     |     -</span>
<a name="23" /><span class="Maybe">      23:</span> <span class="k"> * del_first |          |     L     |     L</span>
<a name="24" /><span class="Maybe">      24:</span> <span class="k"> * del_all   |          |           |     -</span>
<a name="25" /><span class="Maybe">      25:</span> <span class="k"> *</span>
<a name="26" /><span class="Maybe">      26:</span> <span class="k"> * Where &quot;-&quot; stands for no lock is needed, while &quot;L&quot; stands for lock</span>
<a name="27" /><span class="Maybe">      27:</span> <span class="k"> * is needed.</span>
<a name="28" /><span class="Maybe">      28:</span> <span class="k"> *</span>
<a name="29" /><span class="Maybe">      29:</span> <span class="k"> * The list entries deleted via llist_del_all can be traversed with</span>
<a name="30" /><span class="Maybe">      30:</span> <span class="k"> * traversing function such as llist_for_each etc.  But the list</span>
<a name="31" /><span class="Maybe">      31:</span> <span class="k"> * entries can not be traversed safely before deleted from the list.</span>
<a name="32" /><span class="Maybe">      32:</span> <span class="k"> * The order of deleted entries is from the newest to the oldest added</span>
<a name="33" /><span class="Maybe">      33:</span> <span class="k"> * one.  If you want to traverse from the oldest to the newest, you</span>
<a name="34" /><span class="Maybe">      34:</span> <span class="k"> * must reverse the order by yourself before traversing.</span>
<a name="35" /><span class="Maybe">      35:</span> <span class="k"> *</span>
<a name="36" /><span class="Maybe">      36:</span> <span class="k"> * The basic atomic operation of this list is cmpxchg on long.  On</span>
<a name="37" /><span class="Maybe">      37:</span> <span class="k"> * architectures that don&apos;t have NMI-safe cmpxchg implementation, the</span>
<a name="38" /><span class="Maybe">      38:</span> <span class="k"> * list can NOT be used in NMI handlers.  So code that uses the list in</span>
<a name="39" /><span class="Maybe">      39:</span> <span class="k"> * an NMI handler should depend on CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG.</span>
<a name="40" /><span class="Maybe">      40:</span> <span class="k"> *</span>
<a name="41" /><span class="Maybe">      41:</span> <span class="k"> * Copyright 2010,2011 Intel Corp.</span>
<a name="42" /><span class="Maybe">      42:</span> <span class="k"> *   Author: Huang Ying &lt;ying.huang@intel.com&gt;</span>
<a name="43" /><span class="Maybe">      43:</span> <span class="k"> *</span>
<a name="44" /><span class="Maybe">      44:</span> <span class="k"> * This program is free software; you can redistribute it and/or</span>
<a name="45" /><span class="Maybe">      45:</span> <span class="k"> * modify it under the terms of the GNU General Public License version</span>
<a name="46" /><span class="Maybe">      46:</span> <span class="k"> * 2 as published by the Free Software Foundation;</span>
<a name="47" /><span class="Maybe">      47:</span> <span class="k"> *</span>
<a name="48" /><span class="Maybe">      48:</span> <span class="k"> * This program is distributed in the hope that it will be useful,</span>
<a name="49" /><span class="Maybe">      49:</span> <span class="k"> * but WITHOUT ANY WARRANTY; without even the implied warranty of</span>
<a name="50" /><span class="Maybe">      50:</span> <span class="k"> * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the</span>
<a name="51" /><span class="Maybe">      51:</span> <span class="k"> * GNU General Public License for more details.</span>
<a name="52" /><span class="Maybe">      52:</span> <span class="k"> *</span>
<a name="53" /><span class="Maybe">      53:</span> <span class="k"> * You should have received a copy of the GNU General Public License</span>
<a name="54" /><span class="Maybe">      54:</span> <span class="k"> * along with this program; if not, write to the Free Software</span>
<a name="55" /><span class="Maybe">      55:</span> <span class="k"> * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA</span>
<a name="56" /><span class="Maybe">      56:</span> <span class="k"> */</span>
<a name="57" /><span class="Maybe">      57:</span> 
<a name="58" /><span class="Maybe">      58:</span> <span class="f">#</span><span class="n">include</span> <span class="f">&lt;</span><span class="b">linux</span><span class="f">/</span><span class="b">kernel</span><span class="f">.</span><span class="b">h</span><span class="f">&gt;</span>
<a name="59" /><span class="Maybe">      59:</span> <span class="f">#</span><span class="n">include</span> <span class="f">&lt;</span><span class="m">asm</span><span class="f">/</span><a href="cpu.c_macros_ref.html#_Y21weGNoZ18w"><span class="b">cmpxchg</span></a><span class="f">.</span><span class="b">h</span><span class="f">&gt;</span>
<a name="60" /><span class="Maybe">      60:</span> 
<a name="61" /><span class="Maybe">      61:</span> <span class="m">struct</span> <span class="b">llist_head</span> <span class="f">{</span>
<a name="62" /><span class="Maybe">      62:</span>     <span class="m">struct</span> <span class="b">llist_node</span> <span class="f">*</span><span class="b">first</span><span class="f">;</span>
<a name="63" /><span class="Maybe">      63:</span> <span class="f">}</span><span class="f">;</span>
<a name="64" /><span class="Maybe">      64:</span> 
<a name="65" /><span class="Maybe">      65:</span> <span class="m">struct</span> <span class="b">llist_node</span> <span class="f">{</span>
<a name="66" /><span class="Maybe">      66:</span>     <span class="m">struct</span> <span class="b">llist_node</span> <span class="f">*</span><span class="b">next</span><span class="f">;</span>
<a name="67" /><span class="Maybe">      67:</span> <span class="f">}</span><span class="f">;</span>
<a name="68" /><span class="Maybe">      68:</span> 
<a name="69" /><span class="Maybe">      69:</span> <span class="f">#</span><span class="n">define</span> <a href="cpu.c_macros_noref.html#_TExJU1RfSEVBRF9JTklUXzA_"><span class="b">LLIST_HEAD_INIT</span></a><span class="f">(</span><span class="b">name</span><span class="f">)</span>    <span class="f">{</span> <a href="cpu.c_macros_ref.html#_TlVMTF8w"><span class="b">NULL</span></a> <span class="f">}</span>
<a name="70" /><span class="Maybe">      70:</span> <span class="f">#</span><span class="n">define</span> <a href="cpu.c_macros_noref.html#_TExJU1RfSEVBRF8w"><span class="b">LLIST_HEAD</span></a><span class="f">(</span><span class="b">name</span><span class="f">)</span>    <span class="m">struct</span> <span class="b">llist_head</span> <span class="b">name</span> <span class="f">=</span> <a href="cpu.c_macros_noref.html#_TExJU1RfSEVBRF9JTklUXzA_"><span class="b">LLIST_HEAD_INIT</span></a><span class="f">(</span><span class="b">name</span><span class="f">)</span>
<a name="71" /><span class="Maybe">      71:</span> 
<a name="72" /><span class="Maybe">      72:</span> <span class="k">/**</span>
<a name="73" /><span class="Maybe">      73:</span> <span class="k"> * init_llist_head - initialize lock-less list head</span>
<a name="74" /><span class="Maybe">      74:</span> <span class="k"> * @head:    the head for your lock-less list</span>
<a name="75" /><span class="Maybe">      75:</span> <span class="k"> */</span>
<a name="76" /><span class="Maybe">      76:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">void</span> <span class="b">init_llist_head</span><span class="f">(</span><span class="m">struct</span> <span class="b">llist_head</span> <span class="f">*</span><span class="b">list</span><span class="f">)</span>
<a name="77" /><span class="Maybe">      77:</span> <span class="f">{</span>
<a name="78" /><span class="Maybe">      78:</span>     <span class="b">list</span><span class="f">-&gt;</span><span class="b">first</span> <span class="f">=</span> <a href="cpu.c_macros_ref.html#_TlVMTF8w"><span class="b">NULL</span></a><span class="f">;</span>
<a name="79" /><span class="Maybe">      79:</span> <span class="f">}</span>
<a name="80" /><span class="Maybe">      80:</span> 
<a name="81" /><span class="Maybe">      81:</span> <span class="k">/**</span>
<a name="82" /><span class="Maybe">      82:</span> <span class="k"> * llist_entry - get the struct of this entry</span>
<a name="83" /><span class="Maybe">      83:</span> <span class="k"> * @ptr:    the &amp;struct llist_node pointer.</span>
<a name="84" /><span class="Maybe">      84:</span> <span class="k"> * @type:    the type of the struct this is embedded in.</span>
<a name="85" /><span class="Maybe">      85:</span> <span class="k"> * @member:    the name of the llist_node within the struct.</span>
<a name="86" /><span class="Maybe">      86:</span> <span class="k"> */</span>
<a name="87" /><span class="Maybe">      87:</span> <span class="f">#</span><span class="n">define</span> <a href="cpu.c_macros_noref.html#_bGxpc3RfZW50cnlfMA__"><span class="b">llist_entry</span></a><span class="f">(</span><span class="b">ptr</span><span class="f">,</span> <span class="b">type</span><span class="f">,</span> <span class="b">member</span><span class="f">)</span>        \
<a name="88" /><span class="Maybe">      88:</span>     <a href="cpu.c_macros_ref.html#_Y29udGFpbmVyX29mXzA_"><span class="b">container_of</span></a><span class="f">(</span><span class="b">ptr</span><span class="f">,</span> <span class="b">type</span><span class="f">,</span> <span class="b">member</span><span class="f">)</span>
<a name="89" /><span class="Maybe">      89:</span> 
<a name="90" /><span class="Maybe">      90:</span> <span class="k">/**</span>
<a name="91" /><span class="Maybe">      91:</span> <span class="k"> * llist_for_each - iterate over some deleted entries of a lock-less list</span>
<a name="92" /><span class="Maybe">      92:</span> <span class="k"> * @pos:    the &amp;struct llist_node to use as a loop cursor</span>
<a name="93" /><span class="Maybe">      93:</span> <span class="k"> * @node:    the first entry of deleted list entries</span>
<a name="94" /><span class="Maybe">      94:</span> <span class="k"> *</span>
<a name="95" /><span class="Maybe">      95:</span> <span class="k"> * In general, some entries of the lock-less list can be traversed</span>
<a name="96" /><span class="Maybe">      96:</span> <span class="k"> * safely only after being deleted from list, so start with an entry</span>
<a name="97" /><span class="Maybe">      97:</span> <span class="k"> * instead of list head.</span>
<a name="98" /><span class="Maybe">      98:</span> <span class="k"> *</span>
<a name="99" /><span class="Maybe">      99:</span> <span class="k"> * If being used on entries deleted from lock-less list directly, the</span>
<a name="100" /><span class="Maybe">     100:</span> <span class="k"> * traverse order is from the newest to the oldest added entry.  If</span>
<a name="101" /><span class="Maybe">     101:</span> <span class="k"> * you want to traverse from the oldest to the newest, you must</span>
<a name="102" /><span class="Maybe">     102:</span> <span class="k"> * reverse the order by yourself before traversing.</span>
<a name="103" /><span class="Maybe">     103:</span> <span class="k"> */</span>
<a name="104" /><span class="Maybe">     104:</span> <span class="f">#</span><span class="n">define</span> <a href="cpu.c_macros_noref.html#_bGxpc3RfZm9yX2VhY2hfMA__"><span class="b">llist_for_each</span></a><span class="f">(</span><span class="b">pos</span><span class="f">,</span> <span class="b">node</span><span class="f">)</span>            \
<a name="105" /><span class="Maybe">     105:</span>     <span class="m">for</span> <span class="f">(</span><span class="f">(</span><span class="b">pos</span><span class="f">)</span> <span class="f">=</span> <span class="f">(</span><span class="b">node</span><span class="f">)</span><span class="f">;</span> <span class="b">pos</span><span class="f">;</span> <span class="f">(</span><span class="b">pos</span><span class="f">)</span> <span class="f">=</span> <span class="f">(</span><span class="b">pos</span><span class="f">)</span><span class="f">-&gt;</span><span class="b">next</span><span class="f">)</span>
<a name="106" /><span class="Maybe">     106:</span> 
<a name="107" /><span class="Maybe">     107:</span> <span class="k">/**</span>
<a name="108" /><span class="Maybe">     108:</span> <span class="k"> * llist_for_each_entry - iterate over some deleted entries of lock-less list of given type</span>
<a name="109" /><span class="Maybe">     109:</span> <span class="k"> * @pos:    the type * to use as a loop cursor.</span>
<a name="110" /><span class="Maybe">     110:</span> <span class="k"> * @node:    the fist entry of deleted list entries.</span>
<a name="111" /><span class="Maybe">     111:</span> <span class="k"> * @member:    the name of the llist_node with the struct.</span>
<a name="112" /><span class="Maybe">     112:</span> <span class="k"> *</span>
<a name="113" /><span class="Maybe">     113:</span> <span class="k"> * In general, some entries of the lock-less list can be traversed</span>
<a name="114" /><span class="Maybe">     114:</span> <span class="k"> * safely only after being removed from list, so start with an entry</span>
<a name="115" /><span class="Maybe">     115:</span> <span class="k"> * instead of list head.</span>
<a name="116" /><span class="Maybe">     116:</span> <span class="k"> *</span>
<a name="117" /><span class="Maybe">     117:</span> <span class="k"> * If being used on entries deleted from lock-less list directly, the</span>
<a name="118" /><span class="Maybe">     118:</span> <span class="k"> * traverse order is from the newest to the oldest added entry.  If</span>
<a name="119" /><span class="Maybe">     119:</span> <span class="k"> * you want to traverse from the oldest to the newest, you must</span>
<a name="120" /><span class="Maybe">     120:</span> <span class="k"> * reverse the order by yourself before traversing.</span>
<a name="121" /><span class="Maybe">     121:</span> <span class="k"> */</span>
<a name="122" /><span class="Maybe">     122:</span> <span class="f">#</span><span class="n">define</span> <a href="cpu.c_macros_noref.html#_bGxpc3RfZm9yX2VhY2hfZW50cnlfMA__"><span class="b">llist_for_each_entry</span></a><span class="f">(</span><span class="b">pos</span><span class="f">,</span> <span class="b">node</span><span class="f">,</span> <span class="b">member</span><span class="f">)</span>                \
<a name="123" /><span class="Maybe">     123:</span>     <span class="m">for</span> <span class="f">(</span><span class="f">(</span><span class="b">pos</span><span class="f">)</span> <span class="f">=</span> <a href="cpu.c_macros_noref.html#_bGxpc3RfZW50cnlfMA__"><span class="b">llist_entry</span></a><span class="f">(</span><span class="f">(</span><span class="b">node</span><span class="f">)</span><span class="f">,</span> <span class="b">typeof</span><span class="f">(</span><span class="f">*</span><span class="f">(</span><span class="b">pos</span><span class="f">)</span><span class="f">)</span><span class="f">,</span> <span class="b">member</span><span class="f">)</span><span class="f">;</span>    \
<a name="124" /><span class="Maybe">     124:</span>          <span class="f">&amp;</span><span class="f">(</span><span class="b">pos</span><span class="f">)</span><span class="f">-&gt;</span><span class="b">member</span> <span class="f">!=</span> <a href="cpu.c_macros_ref.html#_TlVMTF8w"><span class="b">NULL</span></a><span class="f">;</span>                    \
<a name="125" /><span class="Maybe">     125:</span>          <span class="f">(</span><span class="b">pos</span><span class="f">)</span> <span class="f">=</span> <a href="cpu.c_macros_noref.html#_bGxpc3RfZW50cnlfMA__"><span class="b">llist_entry</span></a><span class="f">(</span><span class="f">(</span><span class="b">pos</span><span class="f">)</span><span class="f">-&gt;</span><span class="b">member</span><span class="f">.</span><span class="b">next</span><span class="f">,</span> <span class="b">typeof</span><span class="f">(</span><span class="f">*</span><span class="f">(</span><span class="b">pos</span><span class="f">)</span><span class="f">)</span><span class="f">,</span> <span class="b">member</span><span class="f">)</span><span class="f">)</span>
<a name="126" /><span class="Maybe">     126:</span> 
<a name="127" /><span class="Maybe">     127:</span> <span class="k">/**</span>
<a name="128" /><span class="Maybe">     128:</span> <span class="k"> * llist_for_each_entry_safe - iterate over some deleted entries of lock-less list of given type</span>
<a name="129" /><span class="Maybe">     129:</span> <span class="k"> *                   safe against removal of list entry</span>
<a name="130" /><span class="Maybe">     130:</span> <span class="k"> * @pos:    the type * to use as a loop cursor.</span>
<a name="131" /><span class="Maybe">     131:</span> <span class="k"> * @n:        another type * to use as temporary storage</span>
<a name="132" /><span class="Maybe">     132:</span> <span class="k"> * @node:    the first entry of deleted list entries.</span>
<a name="133" /><span class="Maybe">     133:</span> <span class="k"> * @member:    the name of the llist_node with the struct.</span>
<a name="134" /><span class="Maybe">     134:</span> <span class="k"> *</span>
<a name="135" /><span class="Maybe">     135:</span> <span class="k"> * In general, some entries of the lock-less list can be traversed</span>
<a name="136" /><span class="Maybe">     136:</span> <span class="k"> * safely only after being removed from list, so start with an entry</span>
<a name="137" /><span class="Maybe">     137:</span> <span class="k"> * instead of list head.</span>
<a name="138" /><span class="Maybe">     138:</span> <span class="k"> *</span>
<a name="139" /><span class="Maybe">     139:</span> <span class="k"> * If being used on entries deleted from lock-less list directly, the</span>
<a name="140" /><span class="Maybe">     140:</span> <span class="k"> * traverse order is from the newest to the oldest added entry.  If</span>
<a name="141" /><span class="Maybe">     141:</span> <span class="k"> * you want to traverse from the oldest to the newest, you must</span>
<a name="142" /><span class="Maybe">     142:</span> <span class="k"> * reverse the order by yourself before traversing.</span>
<a name="143" /><span class="Maybe">     143:</span> <span class="k"> */</span>
<a name="144" /><span class="Maybe">     144:</span> <span class="f">#</span><span class="n">define</span> <a href="cpu.c_macros_noref.html#_bGxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZV8w"><span class="b">llist_for_each_entry_safe</span></a><span class="f">(</span><span class="b">pos</span><span class="f">,</span> <span class="b">n</span><span class="f">,</span> <span class="b">node</span><span class="f">,</span> <span class="b">member</span><span class="f">)</span>                   \
<a name="145" /><span class="Maybe">     145:</span>     <span class="m">for</span> <span class="f">(</span><span class="b">pos</span> <span class="f">=</span> <a href="cpu.c_macros_noref.html#_bGxpc3RfZW50cnlfMA__"><span class="b">llist_entry</span></a><span class="f">(</span><span class="f">(</span><span class="b">node</span><span class="f">)</span><span class="f">,</span> <span class="b">typeof</span><span class="f">(</span><span class="f">*</span><span class="b">pos</span><span class="f">)</span><span class="f">,</span> <span class="b">member</span><span class="f">)</span><span class="f">;</span>               \
<a name="146" /><span class="Maybe">     146:</span>          <span class="f">&amp;</span><span class="b">pos</span><span class="f">-&gt;</span><span class="b">member</span> <span class="f">!=</span> <a href="cpu.c_macros_ref.html#_TlVMTF8w"><span class="b">NULL</span></a> <span class="f">&amp;&amp;</span>                           \
<a name="147" /><span class="Maybe">     147:</span>             <span class="f">(</span><span class="b">n</span> <span class="f">=</span> <a href="cpu.c_macros_noref.html#_bGxpc3RfZW50cnlfMA__"><span class="b">llist_entry</span></a><span class="f">(</span><span class="b">pos</span><span class="f">-&gt;</span><span class="b">member</span><span class="f">.</span><span class="b">next</span><span class="f">,</span> <span class="b">typeof</span><span class="f">(</span><span class="f">*</span><span class="b">n</span><span class="f">)</span><span class="f">,</span> <span class="b">member</span><span class="f">)</span><span class="f">,</span> <span class="m">true</span><span class="f">)</span><span class="f">;</span> \
<a name="148" /><span class="Maybe">     148:</span>          <span class="b">pos</span> <span class="f">=</span> <span class="b">n</span><span class="f">)</span>
<a name="149" /><span class="Maybe">     149:</span> 
<a name="150" /><span class="Maybe">     150:</span> <span class="k">/**</span>
<a name="151" /><span class="Maybe">     151:</span> <span class="k"> * llist_empty - tests whether a lock-less list is empty</span>
<a name="152" /><span class="Maybe">     152:</span> <span class="k"> * @head:    the list to test</span>
<a name="153" /><span class="Maybe">     153:</span> <span class="k"> *</span>
<a name="154" /><span class="Maybe">     154:</span> <span class="k"> * Not guaranteed to be accurate or up to date.  Just a quick way to</span>
<a name="155" /><span class="Maybe">     155:</span> <span class="k"> * test whether the list is empty without deleting something from the</span>
<a name="156" /><span class="Maybe">     156:</span> <span class="k"> * list.</span>
<a name="157" /><span class="Maybe">     157:</span> <span class="k"> */</span>
<a name="158" /><span class="Maybe">     158:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">bool</span> <span class="b">llist_empty</span><span class="f">(</span><span class="m">const</span> <span class="m">struct</span> <span class="b">llist_head</span> <span class="f">*</span><span class="b">head</span><span class="f">)</span>
<a name="159" /><span class="Maybe">     159:</span> <span class="f">{</span>
<a name="160" /><span class="Maybe">     160:</span>     <span class="m">return</span> <a href="cpu.c_macros_ref.html#_QUNDRVNTX09OQ0VfMA__"><span class="b">ACCESS_ONCE</span></a><span class="f">(</span><span class="b">head</span><span class="f">-&gt;</span><span class="b">first</span><span class="f">)</span> <span class="f">==</span> <a href="cpu.c_macros_ref.html#_TlVMTF8w"><span class="b">NULL</span></a><span class="f">;</span>
<a name="161" /><span class="Maybe">     161:</span> <span class="f">}</span>
<a name="162" /><span class="Maybe">     162:</span> 
<a name="163" /><span class="Maybe">     163:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">struct</span> <span class="b">llist_node</span> <span class="f">*</span><span class="b">llist_next</span><span class="f">(</span><span class="m">struct</span> <span class="b">llist_node</span> <span class="f">*</span><span class="b">node</span><span class="f">)</span>
<a name="164" /><span class="Maybe">     164:</span> <span class="f">{</span>
<a name="165" /><span class="Maybe">     165:</span>     <span class="m">return</span> <span class="b">node</span><span class="f">-&gt;</span><span class="b">next</span><span class="f">;</span>
<a name="166" /><span class="Maybe">     166:</span> <span class="f">}</span>
<a name="167" /><span class="Maybe">     167:</span> 
<a name="168" /><span class="Maybe">     168:</span> <span class="m">extern</span> <span class="m">bool</span> <span class="b">llist_add_batch</span><span class="f">(</span><span class="m">struct</span> <span class="b">llist_node</span> <span class="f">*</span><span class="b">new_first</span><span class="f">,</span>
<a name="169" /><span class="Maybe">     169:</span>                 <span class="m">struct</span> <span class="b">llist_node</span> <span class="f">*</span><span class="b">new_last</span><span class="f">,</span>
<a name="170" /><span class="Maybe">     170:</span>                 <span class="m">struct</span> <span class="b">llist_head</span> <span class="f">*</span><span class="b">head</span><span class="f">)</span><span class="f">;</span>
<a name="171" /><span class="Maybe">     171:</span> <span class="k">/**</span>
<a name="172" /><span class="Maybe">     172:</span> <span class="k"> * llist_add - add a new entry</span>
<a name="173" /><span class="Maybe">     173:</span> <span class="k"> * @new:    new entry to be added</span>
<a name="174" /><span class="Maybe">     174:</span> <span class="k"> * @head:    the head for your lock-less list</span>
<a name="175" /><span class="Maybe">     175:</span> <span class="k"> *</span>
<a name="176" /><span class="Maybe">     176:</span> <span class="k"> * Returns true if the list was empty prior to adding this entry.</span>
<a name="177" /><span class="Maybe">     177:</span> <span class="k"> */</span>
<a name="178" /><span class="Maybe">     178:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">bool</span> <span class="b">llist_add</span><span class="f">(</span><span class="m">struct</span> <span class="b">llist_node</span> <span class="f">*</span><span class="m">new</span><span class="f">,</span> <span class="m">struct</span> <span class="b">llist_head</span> <span class="f">*</span><span class="b">head</span><span class="f">)</span>
<a name="179" /><span class="Maybe">     179:</span> <span class="f">{</span>
<a name="180" /><span class="Maybe">     180:</span>     <span class="m">return</span> <span class="b">llist_add_batch</span><span class="f">(</span><span class="m">new</span><span class="f">,</span> <span class="m">new</span><span class="f">,</span> <span class="b">head</span><span class="f">)</span><span class="f">;</span>
<a name="181" /><span class="Maybe">     181:</span> <span class="f">}</span>
<a name="182" /><span class="Maybe">     182:</span> 
<a name="183" /><span class="Maybe">     183:</span> <span class="k">/**</span>
<a name="184" /><span class="Maybe">     184:</span> <span class="k"> * llist_del_all - delete all entries from lock-less list</span>
<a name="185" /><span class="Maybe">     185:</span> <span class="k"> * @head:    the head of lock-less list to delete all entries</span>
<a name="186" /><span class="Maybe">     186:</span> <span class="k"> *</span>
<a name="187" /><span class="Maybe">     187:</span> <span class="k"> * If list is empty, return NULL, otherwise, delete all entries and</span>
<a name="188" /><span class="Maybe">     188:</span> <span class="k"> * return the pointer to the first entry.  The order of entries</span>
<a name="189" /><span class="Maybe">     189:</span> <span class="k"> * deleted is from the newest to the oldest added one.</span>
<a name="190" /><span class="Maybe">     190:</span> <span class="k"> */</span>
<a name="191" /><span class="Maybe">     191:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">struct</span> <span class="b">llist_node</span> <span class="f">*</span><span class="b">llist_del_all</span><span class="f">(</span><span class="m">struct</span> <span class="b">llist_head</span> <span class="f">*</span><span class="b">head</span><span class="f">)</span>
<a name="192" /><span class="Maybe">     192:</span> <span class="f">{</span>
<a name="193" /><span class="Maybe">     193:</span>     <span class="m">return</span> <a href="cpu.c_macros_ref.html#_eGNoZ18w"><span class="b">xchg</span></a><span class="f">(</span><span class="f">&amp;</span><span class="b">head</span><span class="f">-&gt;</span><span class="b">first</span><span class="f">,</span> <a href="cpu.c_macros_ref.html#_TlVMTF8w"><span class="b">NULL</span></a><span class="f">)</span><span class="f">;</span>
<a name="194" /><span class="Maybe">     194:</span> <span class="f">}</span>
<a name="195" /><span class="Maybe">     195:</span> 
<a name="196" /><span class="Maybe">     196:</span> <span class="m">extern</span> <span class="m">struct</span> <span class="b">llist_node</span> <span class="f">*</span><span class="b">llist_del_first</span><span class="f">(</span><span class="m">struct</span> <span class="b">llist_head</span> <span class="f">*</span><span class="b">head</span><span class="f">)</span><span class="f">;</span>
<a name="197" /><span class="Maybe">     197:</span> 
<a name="198" /><span class="Maybe">     198:</span> <span class="m">struct</span> <span class="b">llist_node</span> <span class="f">*</span><span class="b">llist_reverse_order</span><span class="f">(</span><span class="m">struct</span> <span class="b">llist_node</span> <span class="f">*</span><span class="b">head</span><span class="f">)</span><span class="f">;</span>
<a name="199" /><span class="Maybe">     199:</span> 
<a name="200" /><span class="True">     200:</span> <span class="f">#</span><span class="n">endif</span> <span class="k">/* LLIST_H */</span>
<a name="201" /><span class="True">     201:</span> </pre>
  </body>
</html>
